import axios from 'axios';

// 创建axios实例
const api = axios.create({
    baseURL: process.env.NODE_ENV === 'development' ? '/api' : 'http://localhost:8091',
    timeout: 10000,
    withCredentials: true // 确保这个设置为true
});

console.log('API配置:', {
    baseURL: process.env.NODE_ENV === 'development' ? '/api' : 'http://localhost:8091',
    withCredentials: true,
    NODE_ENV: process.env.NODE_ENV
});

// 请求拦截器
api.interceptors.request.use(
    config => {
        // 添加请求调试信息
        console.log('发送请求:', {
            url: config.url,
            method: config.method,
            baseURL: config.baseURL,
            withCredentials: config.withCredentials,
            headers: config.headers
        });
        
        // 可以在这里添加请求头，如token等
        return config;
    },
    error => {
        return Promise.reject(error);
    }
);

// 响应拦截器
api.interceptors.response.use(
    response => {
        // 统一处理响应
        if (response.data.status === 'fail') {
            console.error('请求失败:', response.data.data?.errMsg || response.data.message);
            return Promise.reject(new Error(response.data.data?.errMsg || response.data.message || '请求失败'));
        }
        return response.data;
    },
    error => {
        console.error('请求错误:', error);
        // 处理HTTP状态码错误
        if (error.response) {
            const { status, data } = error.response;
            console.error('错误详情:', data); // 添加详细错误日志
            if (status === 400) {
                const errorMessage = data.message || data.errMsg || data.data?.errMsg || '请求参数错误';
                return Promise.reject(new Error(errorMessage));
            } else if (status === 401) {
                // 未授权，可能需要重新登录
                return Promise.reject(new Error('登录状态已失效，请重新登录'));
            } else if (status === 500) {
                // 服务器内部错误
                const errorMessage = data.message || data.error || '服务器内部错误，请稍后重试';
                console.error('服务器错误详情:', {
                    timestamp: data.timestamp,
                    status: data.status,
                    error: data.error,
                    path: data.path,
                    message: data.message
                });
                return Promise.reject(new Error(errorMessage));
            }
        }
        return Promise.reject(error);
    }
);

// 用户相关API
export const userAPI = {
    // 获取验证码
    getOtp: (teiphon) => api.post('/user/getotp', null, {
        params: { teiphon }
    }),
    // 注册
    register: (userInfo) => api.post('/user/register', null, {
        params: userInfo
    }),
    // 登录
    login: (teiphon, password) => api.post('/user/login', null, {
        params: { teiphon, password }
    }),
    // 获取用户信息
    getUser: (id) => api.get('/user/get', {
        params: { id }
    })
};

// 商品相关API
export const productAPI = {
    // 创建商品
    create: (productInfo) => api.post('/item/create', null, {
        params: productInfo
    }),
    // 获取商品详情
    getDetail: (id) => api.get('/item/get', {
        params: { id }
    }),
    // 获取商品列表
    getList: () => api.get('/item/list'),
    // 获取热点商品列表
    getHotList: () => api.get('/item/hotlist'),
    // 分页获取商品列表
    getPageList: (page, limit) => api.get('/item/listpage', {
        params: { page, limit }
    }),
    // 基于用户协同过滤推荐商品列表
    getRecommendList: (userId, limit) => api.get('/item/recommend', {
        params: { userId, limit }
    })
};

// 搜索相关API
export const searchAPI = {
    // 前缀搜索商品（返回详细信息）
    prefixSearchDetail: (prefix, limit = 10) => api.get('/search/PrefixSearchDetail', {
        params: { prefix, limit }
    }),
    // 前缀搜索商品（只返回ID和标题）
    prefixSearch: (prefix, limit = 10) => api.get('/search/PrefixSearch', {
        params: { prefix, limit }
    })
};

// 订单相关API
export const orderAPI = {
    // 创建订单
    create: (itemId, amount, promoId) => api.post('/order/createorder', null, {
        params: { itemId, amount, promoId }
    })
};

export const invitationAPI = {
    /**
     * 创建邀请（支持图片Base64字符串）
     * @param {Object} invitation - 帖子完整信息对象
     * @returns {Promise}
     */
    createInvitation: (invitation) => api.post('/invitation/createInvitation', invitation),

    /**
     * 查询邀请详情
     * @param {number} postid - 邀请ID
     * @returns {Promise}
     */
    queryInvitationDetail: (postid) => api.get('/invitation/queryInvitationDetail', {
        params: { postid }
    }),

    /**
     * 删除邀请
     * @param {number} postid - 邀请ID
     * @returns {Promise}
     */
    deleteInvitation: (postid) => api.post('/invitation/deleteInvitation', null, {
        params: { postid }
    }),

    /**
     * 更新邀请
     * @param {Object} invitationVO - 邀请VO对象
     * @returns {Promise}
     */
    updateInvitation: (invitationVO) => api.post('/invitation/updateInvitation', invitationVO),

    /**
     * 查询邀请列表（支持排序）
     * @param {string} fig - 排序方式（"按点赞量排序", "按阅读量排序", "按创建时间排序"）
     * @returns {Promise}
     */
    queryInvitationList: (fig = "按点赞量排序") => {
        console.log('发送查询帖子列表请求，排序方式:', fig);
        return api.get('/invitation/queryInvitationList', {
            params: { fig }
        });
    },

    /**
     * 按用户名查询邀请列表
     * @param {string} username - 用户名
     * @returns {Promise}
     */
    queryInvitationListByUsername: (username) => api.get('/invitation/queryInvitationListByUsername', {
        params: { username }
    }),

    /**
     * 按分类名称查询邀请列表
     * @param {string} categoryname - 分类名称
     * @returns {Promise}
     */
    queryInvitationListByCategoryName: (categoryname) => api.get('/invitation/queryInvitationListByCategoryName', {
        params: { categoryname }
    }),

    /**
     * 按标题关键字查询邀请列表
     * @param {string} titleWord - 标题关键字
     * @returns {Promise}
     */
    queryInvitationListByTitleWord: (titleWord) => api.get('/invitation/queryInvitationListByTitleWord', {
        params: { titleWord }
    }),

    /**
     * 点赞帖子
     * @param {number} postid - 帖子ID
     * @returns {Promise}
     */
    likeInvitation: (postid) => api.post('/invitation/likeInvitation', null, {
        params: { postid }
    }),

    /**
     * 取消点赞
     * @param {number} postid - 帖子ID
     * @returns {Promise}
     */
    unlikeInvitation: (postid) => api.post('/invitation/unlikeInvitation', null, {
        params: { postid }
    }),

    /**
     * 点赞帖子（乐观锁方式）
     * @param {number} postid - 帖子ID
     * @returns {Promise}
     */
    likeInvitationOptimistic: (postid) => api.post('/invitation/likeInvitationOptimistic', null, {
        params: { postid }
    }),

    /**
     * 取消点赞（乐观锁方式）
     * @param {number} postid - 帖子ID
     * @returns {Promise}
     */
    unlikeInvitationOptimistic: (postid) => api.post('/invitation/unlikeInvitationOptimistic', null, {
        params: { postid }
    }),

    /**
     * 添加评论并返回评论信息
     * @param {number} postid - 帖子ID
     * @param {string} commentContent - 评论内容
     * @returns {Promise}
     */
    addCommentandReturn: (postid, commentContent) => api.post('/invitation/addCommentandReturn', null, {
        params: { postid, commentContent }
    }),

    /**
     * 根据帖子ID获取评论列表
     * @param {number} postid - 帖子ID
     * @returns {Promise}
     */
    getCommentsByPostId: (postid) => api.get('/invitation/getCommentsByPostId', {
        params: { postid }
    }),

    /**
     * 删除评论
     * @param {number} commentid - 评论ID
     * @returns {Promise}
     */
    deleteComment: (commentid) => api.post('/invitation/deleteComment', null, {
        params: { commentid }
    }),
};



export default api;